package algorithms;



import com.sun.org.apache.xalan.internal.xsltc.compiler.util.StringStack;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

/**
 * @功能
 * @创建时间 2020/5/17
 */
public class Test2 {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList();

        String target = "O_N_1234567890123456789";
        String pattern  = "[A-Z]_[CN]_\\d{19}";
        Pattern p1 = Pattern.compile(pattern);
        System.err.println(p1.matcher(target).matches());
    }
    public static String wangDaChui(String a) {
        int same = 0;
        char[] chars = a.toCharArray();
        Stack<Character> stack = new Stack<>();
        StringBuilder builder = new StringBuilder();
        for (int index1 = 0; index1 < chars.length; index1++) {
            //如果是第一个字母，指甲压入站
            if (index1 < 1) {
                stack.push(chars[index1]);
                continue;
            }
            // 如果占中最后字母和当前字母不一致，判断三个字母是不是连续不同，是就表示
            // 当前没有连续想等字母，将连续想等字符清0并直接压入站
            if (stack.peek() != chars[index1]) {
                char tmp = stack.pop();
                if (stack.size() != 0 && stack.peek() != tmp){
                    same = 0;
                }
                stack.push(tmp);
                stack.push(chars[index1]);
                continue;
            }
            // 如果占中最后一个字母和当前字母相同，取前一个字母，判断与当前字母是否相同
            // 如果相同，则字符串有错，去除重复字母，如果不同，则判断是否有连续相同字符
            // 如果存在则弹出最后的一个字符，并将新字符压入，并将重复数减1
            // 否则将字符压入并将重复数加1
            if (stack.peek() == chars[index1]) {
                char tmp1 = stack.pop();
                if (stack.peek() == chars[index1]) {
                    stack.push(tmp1);
                } else if(same < 2){
                    stack.push(tmp1);
                    stack.push(chars[index1]);
                    same ++;
                }else {
                    stack.pop();
                    stack.push(tmp1);
                    stack.push(chars[index1]);
                    same --;
                }
            }
        }
        while (stack.size() != 0){
            builder.append(stack.pop());
        }
        return builder.reverse().toString();
    }

    private static void Find(int[] arr, int w) {
        int count =w/arr.length;
        int p = w%arr.length;
        int l,r;
        sorte(arr);
        l=arr[count];
        r=arr[p];
        int err[]={l,r};
        for (int v = 0; v < err.length; v++) {
            System.out.println(err[v] + "");
        }

    }
    private static void sorte(int[] arr) {
        for (int i = 0; i < arr.length; i++) {
            findMax(arr, i);
        }
    }

    static void findMax(int[] arr, int i) {
        for (int j = i; j < arr.length - 1; j++) {
            if (arr[j] > arr[j + 1]) {
                swap(arr, j, j + 1);
            }
            ;
        }
    }

    public static void swap(int[] arr, int min, int max) {
        int tmp = arr[max];
        arr[max] = arr[min];
        arr[min] = tmp;
    }
    private static int findMin(int[] arr) {
        int min=arr[0];
        for (int i=0;i<arr.length;i++){
            min = min<arr[i]?min:arr[i];
        }
        return min;
    }
}
